home *** CD-ROM | disk | FTP | other *** search
/ .net 2002 March / DotNetMagazine-Issue107-Coverdisc-NET107-02-03-PCMac.bin / pc / PC Software / picks / HTTrack / httrack-3.22-3.exe / {app} / src / htscatchurl.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-11-17  |  7.8 KB  |  297 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: URL catch .h                                           */
  34. /* Author: Xavier Roche                                         */
  35. /* ------------------------------------------------------------ */
  36.  
  37. // Fichier intercepteur d'URL .c
  38.  
  39. /* specific definitions */
  40. /* specific definitions */
  41. #include "htsbase.h"
  42. #include "htsnet.h"
  43. #include "htslib.h"
  44. #include <stdio.h>
  45. #include <stdlib.h>
  46. #include <string.h>
  47. #include <time.h>
  48. #include <fcntl.h>
  49. #if HTS_WIN
  50. #else
  51. #include <arpa/inet.h>
  52. #endif
  53. /* END specific definitions */
  54.  
  55. /* dÈfinitions globales */
  56. #include "htsglobal.h"
  57.  
  58. /* htslib */
  59. /*#include "htslib.h"*/
  60.  
  61. /* catch url */
  62. #include "htscatchurl.h"
  63.  
  64.  
  65. // URL Link catcher
  66.  
  67. // 0- Init the URL catcher with standard port
  68.  
  69. // catch_url_init(&port,&return_host);
  70. HTSEXT_API T_SOC catch_url_init_std(int* port_prox,char* adr_prox) {
  71.   T_SOC soc;
  72.   int try_to_listen_to[]={8080,3128,80,81,82,8081,3129,31337,0,-1};
  73.   int i=0;
  74.   do {
  75.     soc=catch_url_init(&try_to_listen_to[i],adr_prox);
  76.     *port_prox=try_to_listen_to[i];
  77.     i++;
  78.   } while( (soc == INVALID_SOCKET) && (try_to_listen_to[i]>=0));
  79.   return soc;
  80. }
  81.  
  82.  
  83. // 1- Init the URL catcher
  84.  
  85. // catch_url_init(&port,&return_host);
  86. HTSEXT_API T_SOC catch_url_init(int* port,char* adr) {
  87.   T_SOC soc = INVALID_SOCKET;
  88.   char h_loc[256+2];
  89.  
  90.   /*
  91. #ifdef _WIN32
  92.   {
  93.     WORD   wVersionRequested;
  94.     WSADATA wsadata;
  95.     int stat;
  96.     wVersionRequested = 0x0101;
  97.     stat = WSAStartup( wVersionRequested, &wsadata );
  98.     if (stat != 0) {
  99.       return INVALID_SOCKET;
  100.     } else if (LOBYTE(wsadata.wVersion) != 1  && HIBYTE(wsadata.wVersion) != 1) {
  101.       WSACleanup();
  102.       return INVALID_SOCKET;
  103.     }
  104.   }
  105. #endif
  106.   */
  107.  
  108.   if (gethostname(h_loc,256)==0) {    // host name
  109.     SOCaddr server;
  110.     int server_size=sizeof(server);
  111.     t_hostent* hp_loc;
  112.     t_fullhostent buffer;
  113.  
  114.     // effacer structure
  115.     memset(&server, 0, sizeof(server));
  116.     
  117.     if ( (hp_loc=vxgethostbyname(h_loc, &buffer)) ) {  // notre host      
  118.  
  119.       // copie adresse
  120.       SOCaddr_copyaddr(server, server_size, hp_loc->h_addr_list[0], hp_loc->h_length);
  121.  
  122.       if ( (soc=socket(SOCaddr_sinfamily(server), SOCK_STREAM, 0)) != INVALID_SOCKET) {
  123.         SOCaddr_initport(server, *port);
  124.         if ( bind(soc,(struct sockaddr*) &server,server_size) == 0 ) {
  125.           SOCaddr server2;
  126.           int len;
  127.           len=sizeof(server2);
  128.           // effacer structure
  129.           memset(&server2, 0, sizeof(server2));
  130.           if (getsockname(soc,(struct sockaddr*) &server2,&len) == 0) {
  131.             *port=ntohs(SOCaddr_sinport(server));  // rÈcupÈrer port
  132.             if (listen(soc,10)>=0) {    // au pif le 10
  133.               SOCaddr_inetntoa(adr, 128, server2, len);
  134.             } else {
  135. #if _WIN32
  136.               closesocket(soc);
  137. #else
  138.               close(soc);
  139. #endif
  140.               soc=INVALID_SOCKET;
  141.             }
  142.             
  143.             
  144.           } else {
  145. #if _WIN32
  146.             closesocket(soc);
  147. #else
  148.             close(soc);
  149. #endif
  150.             soc=INVALID_SOCKET;
  151.           }
  152.           
  153.           
  154.         } else {
  155. #if _WIN32
  156.           closesocket(soc);
  157. #else
  158.           close(soc);
  159. #endif
  160.           soc=INVALID_SOCKET;
  161.         }
  162.       }
  163.     }
  164.   }
  165.   return soc;
  166. }
  167.  
  168. // 2 - Wait for URL
  169.  
  170. // catch_url
  171. // returns 0 if error
  172. // url: buffer where URL must be stored - or ip:port in case of failure
  173. // data: 32Kb
  174. HTSEXT_API int catch_url(T_SOC soc,char* url,char* method,char* data) {
  175.   int retour=0;
  176.  
  177.   // connexion (accept)
  178.   if (soc != INVALID_SOCKET) {
  179.     T_SOC soc2;
  180.     struct sockaddr dummyaddr;
  181.     int dummylen = sizeof(struct sockaddr);  
  182.     while ( (soc2=accept(soc,&dummyaddr,&dummylen)) == INVALID_SOCKET);
  183.   /*
  184. #ifdef _WIN32
  185.     closesocket(soc);
  186. #else
  187.     close(soc);
  188. #endif
  189.   */
  190.     soc = soc2;
  191.     /* INFOS */
  192.     {
  193.       SOCaddr server2;
  194.       int len;
  195.       len=sizeof(server2);
  196.       // effacer structure
  197.       memset(&server2, 0, sizeof(server2));
  198.       if (getpeername(soc,(struct sockaddr*) &server2,&len) == 0) {
  199.         char dot[256+2];
  200.         SOCaddr_inetntoa(dot, 256, server2, sizeof(server2));
  201.         sprintf(url,"%s:%d", dot, htons(SOCaddr_sinport(server2)));  
  202.       }
  203.     }
  204.     /* INFOS */
  205.  
  206.     // rÈception
  207.     if (soc != INVALID_SOCKET) {
  208.       char line[1000];
  209.       char protocol[256];
  210.       line[0]=protocol[0]='\0';
  211.       //
  212.       socinput(soc,line,1000);
  213.       if (strnotempty(line)) {
  214.         if (sscanf(line,"%s %s %s",method,url,protocol) == 3) {
  215.           char url_adr[HTS_URLMAXSIZE*2];
  216.           char url_fil[HTS_URLMAXSIZE*2];
  217.           // mÈthode en majuscule
  218.           int i,r=0;
  219.           url_adr[0]=url_fil[0]='\0';
  220.           //
  221.           for(i=0;i<(int) strlen(method);i++) {
  222.             if ((method[i]>='a') && (method[i]<='z'))
  223.               method[i]-=('a'-'A');
  224.           }
  225.           // adresse du lien
  226.           if (ident_url_absolute(url,url_adr,url_fil)>=0) {
  227.             // Traitement des en-tÍtes
  228.             char loc[HTS_URLMAXSIZE*2];
  229.             htsblk blkretour;
  230.             memset(&blkretour, 0, sizeof(htsblk));    // effacer
  231.             blkretour.location=loc;    // si non nul, contiendra l'adresse vÈritable en cas de moved xx
  232.             // Lire en tÍtes restants
  233.             sprintf(data,"%s %s %s\r\n",method,url_fil,protocol);
  234.             while(strnotempty(line)) {
  235.               socinput(soc,line,1000);
  236.               treathead(NULL,NULL,NULL,&blkretour,line);  // traiter
  237.               strcatbuff(data,line);
  238.               strcatbuff(data,"\r\n");
  239.             }
  240.             // CR/LF final de l'en tÍte inutile car dÈja placÈ via la ligne vide juste au dessus
  241.             //strcatbuff(data,"\r\n");
  242.             if (blkretour.totalsize>0) {
  243.               int len=(int)min(blkretour.totalsize,32000);
  244.               int pos=strlen(data);
  245.               // Copier le reste (post Èventuel)
  246.               while((len>0) && ((r=recv(soc,(char*) data+pos,len,0))>0) ) {
  247.                 pos+=r;
  248.                 len-=r;
  249.                 data[pos]='\0';       // terminer par NULL
  250.               }
  251.             }
  252.             // Envoyer page
  253.             sprintf(line,CATCH_RESPONSE);
  254.             send(soc,line,strlen(line),0);
  255.             // OK!
  256.             retour=1;
  257.           }
  258.         }
  259.       }  // sinon erreur
  260.     }
  261.   }
  262.   if (soc != INVALID_SOCKET) {
  263. #ifdef _WIN32
  264.     closesocket(soc);
  265.     /*
  266.     WSACleanup();
  267.     */
  268. #else
  269.     close(soc);
  270. #endif
  271.   }
  272.   return retour;
  273. }
  274.  
  275.  
  276.  
  277. // Lecture de ligne sur socket
  278. void socinput(T_SOC soc,char* s,int max) {
  279.   int c;
  280.   int j=0;
  281.   do {
  282.     unsigned char b;
  283.     if (recv(soc,(char*) &b,1,0)==1) {
  284.       c=b;
  285.       switch(c) {
  286.         case 13: break;  // sauter CR
  287.         case 10: c=-1; break;
  288.         case 9: case 12: break;  // sauter ces caractËres
  289.         default: s[j++]=(char) c; break;
  290.       }
  291.     } else
  292.       c=EOF;
  293.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  294.   s[j++]='\0';
  295. }
  296.  
  297.